package com.wasion.core.util;

import java.io.ByteArrayOutputStream;

public class ConverterXBaseUtil {

    /*
     * 16进制数字字符集
     */
    private static String hexString = "0123456789ABCDEF";

    // Ascii码 转换成字符串。
    public static String asciiToString(String value) {
	StringBuffer sbu = new StringBuffer();
	String[] chars = value.split(",");
	for (int i = 0; i < chars.length; i++) {
	    sbu.append((char) Integer.parseInt(chars[i]));
	}
	return sbu.toString();
    }

    // public static void main(String[] args)
    // {
    // System.out.println(encode("中文"));
    // System.out.println(decode(encode("中文")));
    // }

    /** BCD码转为10进制串 */
    public static String bcd2Str(byte[] bytes) {

	StringBuffer temp = new StringBuffer(bytes.length * 2);

	for (int i = 0; i < bytes.length; i++) {
	    temp.append((byte) ((bytes[i] & 0xf0) >>> 4));
	    temp.append((byte) (bytes[i] & 0x0f));
	}

	return temp.toString().substring(0, 1).equalsIgnoreCase("0 ") ? temp
		.toString().substring(1) : temp.toString();
    }

    /**
     * @param bArray
     * @return String in Hext format
     */
    public static final String bytesToHexString(byte[] aArray) {
	StringBuffer sb = new StringBuffer(aArray.length);
	String sTemp;
	for (int i = 0; i < aArray.length; i++) {
	    sTemp = Integer.toHexString(0xFF & aArray[i]);
	    if (sTemp.length() < 2)
		sb.append(0);
	    sb.append(sTemp.toUpperCase());
	}
	return sb.toString();
    }
    
    //只读有效部分（不为零的字节）。 F232驱动专用
    public static final String bytesToHexString(byte[] aArray, int length) {
	StringBuffer sb = new StringBuffer(aArray.length);
	String sTemp;
	for (int i = 0; i < length; i++) {
	    sTemp = Integer.toHexString(0xFF & aArray[i]);
	    if (sTemp.length() < 2)
		sb.append(0);
	    sb.append(sTemp.toUpperCase());
	}
	return sb.toString();
    }

    /*
     * 将16进制数字解码成字符串,适用于所有字符（包括中文）
     */
    public static String decode(String bytes) {
	ByteArrayOutputStream baos = new ByteArrayOutputStream(
		bytes.length() / 2);
	// 将每2位16进制整数组装成一个字节
	for (int i = 0; i < bytes.length(); i += 2)
	    baos.write((hexString.indexOf(bytes.charAt(i)) << 4 | hexString
		    .indexOf(bytes.charAt(i + 1))));
	return new String(baos.toByteArray());
    }

    /*
     * 将字符串编码成Ascii码 再用16进制数字表示,适用于所有字符（包括中文）
     * 
     * e.g 'a' = 97; => 97 -> 0x61
     */
    public static String encode(String str) {
	// 根据默认编码获取字节数组
	byte[] bytes = str.getBytes();
	StringBuilder sb = new StringBuilder(bytes.length * 2);
	// 将字节数组中每个字节拆解成2位16进制整数
	for (int i = 0; i < bytes.length; i++) {
	    sb.append(hexString.charAt((bytes[i] & 0xf0) >> 4));
	    sb.append(hexString.charAt((bytes[i] & 0x0f) >> 0));
	}
	return sb.toString();
    }

    /**
     * 加入空格，格式化输入
     * 
     * @param hexString
     * @return
     */
    public static String format(String hexString) {

	// format the output of the bytestream
	StringBuffer sb = new StringBuffer();
	for (int i = 0; i < hexString.length();) {
	    sb = sb.append(hexString.substring(i, i + 2) + " ");
	    i = i + 2;
	}

	return sb.toString();
    }

    //
    //
    // /** 10进制串转为BCD码 */
    // public static byte[] str2Bcd(String str)
    // {
    // if (str.length() % 2 != 0)
    // str = "0 " + str;
    // StringBuffer sb = new StringBuffer(str);
    // ByteBuffer bb = ByteBuffer.allocate(str.length() / 2);
    // int i = 0;
    // while (i < str.length())
    // {
    // bb.put((byte) ((Integer.parseInt(sb.substring(i, i + 1))) << 4 |
    // Integer.parseInt(sb
    // .substring(i + 1, i + 2))));
    // i = i + 2;
    // }
    // return bb.array();
    // }

    // byte array ת���� 16���� �ַ�
    public static String getHexString(byte[] b) {
	String result = "";
	for (int i = 0; i < b.length; i++) {
	    result += Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1)
		    + " ";
	}
	return result;

    }

    /**
     * 人民币转成大写
     * 
     * @param value
     * @return String
     */
    public static String hangeToBig(double value) {
	char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
	char[] vunit = { '万', '亿' }; // 段名表示
	char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
	long midVal = (long) (value * 100); // 转化成整形
	String valStr = String.valueOf(midVal); // 转化成字符串

	String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
	String rail = valStr.substring(valStr.length() - 2); // 取小数部分

	String prefix = ""; // 整数部分转化的结果
	String suffix = ""; // 小数部分转化的结果
	// 处理小数点后面的数
	if (rail.equals("00")) { // 如果小数部分为0
	    suffix = "整";
	} else {
	    suffix = digit[rail.charAt(0) - '0'] + "角"
		    + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
	}
	// 处理小数点前面的数
	char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
	char zero = '0'; // 标志'0'表示出现过0
	byte zeroSerNum = 0; // 连续出现0的次数
	for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字
	    int idx = (chDig.length - i - 1) % 4; // 取段内位置
	    int vidx = (chDig.length - i - 1) / 4; // 取段位置
	    if (chDig[i] == '0') { // 如果当前字符是0
		zeroSerNum++; // 连续0次数递增
		if (zero == '0') { // 标志
		    zero = digit[0];
		} else if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
		    prefix += vunit[vidx - 1];
		    zero = '0';
		}
		continue;
	    }
	    zeroSerNum = 0; // 连续0次数清零
	    if (zero != '0') { // 如果标志不为0,则加上,例如万,亿什么的
		prefix += zero;
		zero = '0';
	    }
	    prefix += digit[chDig[i] - '0']; // 转化该数字表示
	    if (idx > 0)
		prefix += hunit[idx - 1];
	    if (idx == 0 && vidx > 0) {
		prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
	    }
	}

	if (prefix.length() > 0)
	    prefix += '圆'; // 如果整数部分存在,则有圆的字样
	return prefix + suffix; // 返回正确表示
    }

    // 这个是 ICE 下发档案时，组帧后转换发送用的。
    public static byte[] hexStringToByteArray(String hexString) {
	int len = hexString.length();
	byte[] data = new byte[len / 2];
	for (int i = 0; i < len; i += 2) {
	    data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character
		    .digit(hexString.charAt(i + 1), 16));
	}
	return data;
    }

    /*
     * 讲 一个 整数 转换成 2个字节的byte[]
     */
    public static byte[] intTo2bytes(int num) {
	byte[] b = new byte[2];
	for (int i = 0; i < 2; i++) {
	    b[i] = (byte) (num >> (8 - 8 * i));
	}
	return b;
    }

    // 整数 转换成4 个字节 的byte[]
    public static final byte[] intToByteArray(int value) {
	return new byte[] { (byte) (value >>> 24), (byte) (value >>> 16),
		(byte) (value >>> 8), (byte) value };
    }

    public static void main(String[] args) {

	String s = "abcd1234";
	System.out.println("String s = " + stringToAscii(s));

	System.out.println("String s = " + encode(s));

	String ascii = "00";
	System.out.println("String ascii = " + decode(ascii));
    }

    /** */
    /**
     * @函数功能: 10进制串转为BCD码
     * @输入参数: 10进制串
     * @输出结果: BCD码
     */
    public static byte[] str2Bcd(String asc) {
	int len = asc.length();
	int mod = len % 2;

	if (mod != 0) {
	    asc = "0" + asc;
	    len = asc.length();
	}

	byte abt[] = new byte[len];
	if (len >= 2) {
	    len = len / 2;
	}

	byte bbt[] = new byte[len];
	abt = asc.getBytes();
	int j, k;

	for (int p = 0; p < asc.length() / 2; p++) {
	    if ((abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
		j = abt[2 * p] - '0';
	    } else if ((abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
		j = abt[2 * p] - 'a' + 0x0a;
	    } else {
		j = abt[2 * p] - 'A' + 0x0a;
	    }

	    if ((abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
		k = abt[2 * p + 1] - '0';
	    } else if ((abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
		k = abt[2 * p + 1] - 'a' + 0x0a;
	    } else {
		k = abt[2 * p + 1] - 'A' + 0x0a;
	    }

	    int a = (j << 4) + k;
	    byte b = (byte) a;
	    bbt[p] = b;
	}
	return bbt;
    }

    /*
     * 将字符串的每个字符转换成Ascii表示，并添加 "," 分开
     * 
     * @param String value
     * 
     * @return String
     */
    public static String stringToAscii(String value) {
	StringBuffer sbu = new StringBuffer();
	char[] chars = value.toCharArray();

	for (int i = 0; i < chars.length; i++) {
	    if (i != chars.length - 1) {
		sbu.append((int) chars[i]).append(",");
	    } else {
		sbu.append((int) chars[i]);
	    }
	}
	return sbu.toString();
    }

    /**
     * 将number String转成BCD码
     * 
     * @param s
     * @return
     */
    public static byte[] StrToBCDBytes(String s) {

	if (s.length() % 2 != 0) {
	    s = "0" + s;
	}
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	char[] cs = s.toCharArray();
	for (int i = 0; i < cs.length; i += 2) {
	    int high = cs[i] - 48;
	    int low = cs[i + 1] - 48;
	    baos.write(high << 4 | low);
	}
	return baos.toByteArray();
    }

    /**
     * 16进制的字符串表示转成字节数组
     * 
     * @param hexString
     *            16进制格式的字符串
     * @return 转换后的字节数组
     **/
    public static byte[] toByteArray(String hexString) {
	// if (StringUtils.isEmpty(hexString))
	// throw new
	// IllegalArgumentException("this hexString must not be empty");

	hexString = hexString.toLowerCase();
	final byte[] byteArray = new byte[hexString.length() / 2];
	int k = 0;
	for (int i = 0; i < byteArray.length; i++) {
	    // 因为是16进制，最多只会占用4位，转换成字节需要两个16进制的字符，高位在先
	    // byte high = (byte) (Character.digit(hexString.charAt(k), 16) &
	    // 0xff);
	    byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
	    // byteArray[i] = (byte) (high << 4 | low);
	    byteArray[i] = (low);
	    k += 1;
	}
	return byteArray;
    }

    // 转化字符串为十六进制编码
    public static String toHexString(String s) {
	String str = "";
	for (int i = 0; i < s.length(); i++) {
	    int ch = s.charAt(i);
	    String s4 = Integer.toHexString(ch);
	    str = str + s4;
	}
	return str;
    }

    // 转化十六进制编码为字符串
    public static String toStringHex(String s) {
	byte[] baKeyword = new byte[s.length() / 2];
	for (int i = 0; i < baKeyword.length; i++) {
	    try {
		baKeyword[i] = (byte) (0xff & Integer.parseInt(
			s.substring(i * 2, i * 2 + 2), 16));
	    } catch (Exception e) {
		e.printStackTrace();
	    }
	}

	try {
	    s = new String(baKeyword, "utf-8");// UTF-16le:Not
	} catch (Exception e1) {
	    e1.printStackTrace();
	}
	return s;
    }
}
